// pages/index/search/search.js
let app = getApp();

Page({
  data: {
    url: '',
    searchValue: '', // 搜索框内容
    isSearching: false,

    // 分别存储四类结果
    courseResults: [],
    expertResults: [],
    articleResults: [],
    testResults: [],

    userSearchRecords: [], // 历史记录
  },
  gotoAllkc() {
    wx.navigateTo({ url: '/pages/course/zxkc/zxkc' });
  },

  // 跳转到专家列表页
  gotoAllzj() {
    wx.switchTab({
      url: '/pages/consult/consult',
    });
  },

  // 跳转到文章列表页
  gotoAllwz() {
    wx.navigateTo({ url: '/pages/index/article/article' });
  },

  // 跳转到测评列表页
  gotoAllcs() {
    wx.navigateTo({ url: '/pages/index/PsychologicalTest/PsychologicalTest' });
  },
  onLoad() {
    this.setData({ url: app.globalData.url });
    this.getUserSearchRecord(); // 加载历史记录
  },

  // 输入框内容变化
  onInput(e) {
    const value = e.detail.value;
    this.setData({ searchValue: value });

    // 如果清空了输入框，就重置结果并显示历史记录
    if (value.trim() === '') {
      this.resetResults();
      return;
    }

    // 如果有内容，开始搜索
    this.performSearch(value.trim());
  },

  // 执行搜索（核心函数）
  performSearch(keyword) {
    this.setData({ isSearching: true });
    // 重置之前的结果
    this.resetResults();

    // 并行发起四个搜索请求
    Promise.all([
      this.searchCourses(keyword),
      this.searchExperts(keyword),
      this.searchArticles(keyword),
      this.searchTests(keyword)
    ]).then(() => {
      // 所有请求都完成后
      this.setData({ isSearching: false });
      // 可以在这里保存搜索记录
      this.saveSearchRecord(keyword);
    }).catch(err => {
      console.error('搜索过程中出错', err);
      this.setData({ isSearching: false });
    });
  },

  // 重置所有结果
  resetResults() {
    this.setData({
      courseResults: [],
      expertResults: [],
      articleResults: [],
      testResults: []
    });
  },

  // 搜索课程
  searchCourses(keyword) {
    return new Promise((resolve, reject) => {
      wx.request({
        url: this.data.url + 'controller/page',
        method: 'GET',
        data: { courseName: keyword, pageNum: 1, pageSize: 5 }, // 限制数量，避免页面过长
        success: (resp) => {
          if (resp.statusCode === 200 && resp.data?.data?.list) {
            this.setData({ courseResults: resp.data.data.list });
            resolve();
          } else {
            resolve(); // 即使无结果也算完成
          }
        },
        fail: reject
      });
    });
  },

  // 搜索专家 (接口路径和参数请根据实际调整)
  searchExperts(keyword) {
    return new Promise((resolve, reject) => {
      wx.request({
        url: this.data.url + 'consultant/page',
        method: 'GET',
        data: { name: keyword, pageNum: 1, pageSize: 5 },
        success: (resp) => {
          if (resp.statusCode === 200 && resp.data?.data?.list) {
            this.setData({ expertResults: resp.data.data.list });
            resolve();
          } else {
            resolve();
          }
        },
        fail: reject
      });
    });
  },

  // 搜索文章 (接口路径和参数请根据实际调整)
  searchArticles(keyword) {
    return new Promise((resolve, reject) => {
      wx.request({
        url: this.data.url + 'article/byPage',
        method: 'GET',
        data: { title: keyword, pageNum: 1, pageSize: 5 },
        success: (resp) => {
          if (resp.statusCode === 200 && resp.data?.data?.list) {
            this.setData({ articleResults: resp.data.data.list });
            resolve();
          } else {
            resolve();
          }
        },
        fail: reject
      });
    });
  },

  // 搜索测试 (接口路径和参数请根据实际调整)
  searchTests(keyword) {
    return new Promise((resolve, reject) => {
      wx.request({
        url: this.data.url + 'PsyTest/getPages',
        method: 'GET',
        data: { name: keyword, pageNum: 1, pageSize: 5 },
        success: (resp) => {
          if (resp.statusCode === 200 && resp.data?.data?.list) {
            this.setData({ testResults: resp.data.data.list });
            resolve();
          } else {
            resolve();
          }
        },
        fail: reject
      });
    });
  },

  // 保存搜索记录 (复用您已有的逻辑)
  saveSearchRecord(keyword) {
    const userId = app.globalData.userInfo?.id;
    if (!userId) return;

    wx.request({
      url: this.data.url + 'userSearchRecord/user/'+userId,
      method: 'GET',
      success: (queryResp) => {
        if (queryResp.statusCode === 200 && Array.isArray(queryResp.data?.data)) {
          const allRecords = queryResp.data.data; // 从服务器获取的完整记录列表
          const exists = allRecords.some(record => record.content === keyword); // 检查是否已存在
  
          // ✅ 第二步：根据查询结果决定是否需要保存
          if (!exists) {
            // 如果不存在，则执行保存（POST）
            this.createSearchRecord(keyword, userId);
          } else {
            // 如果已存在，可以选择：
            // 1. 什么都不做（不更新数据库，但前端仍会去重置顶）
            // 2. 或者，调用一个“更新时间”的接口（如果后端提供了）
            console.log(`【搜索记录已存在，跳过保存】${keyword}`);
            // 即使不保存，我们仍然要更新前端显示（去重置顶）
            this.updateFrontendRecords(keyword);
          }
        } else {
          // 查询失败，按不存在处理，尝试保存
          this.createSearchRecord(keyword, userId);
        }
      },
      fail: (err) => {
        console.error('【查询搜索记录失败】', err);
        // 查询失败，保守起见，还是尝试保存
        this.createSearchRecord(keyword, userId);
      }
    });
  },
  // ✅ 将创建记录的逻辑独立出来
createSearchRecord(keyword, userId) {
  wx.request({
    url: this.data.url + 'userSearchRecord',
    method: 'POST',
    data: { content: keyword, userId: userId },
    success: (saveResp) => {
      console.log('【搜索记录保存成功】', saveResp);
      // 成功后，更新前端显示
      this.updateFrontendRecords(keyword);
    },
    fail: (err) => {
      console.error('【搜索记录保存失败】', err);
    }
  });
},

// ✅ 将更新前端记录的逻辑独立出来（去重置顶）
updateFrontendRecords(keyword) {
  const currentRecords = this.data.userSearchRecords;
  const filteredRecords = currentRecords.filter(record => record.content !== keyword);
  const newRecords = [{ content: keyword }, ...filteredRecords];
  this.setData({ userSearchRecords: newRecords });
},

  // 点击结果项跳转
  gotoDetail(e) {
    const id = e.currentTarget.dataset.id;
    const type = e.currentTarget.dataset.type;
    let url = '';

    switch(type) {
      case 'course':
        url = `/pages/course/zxkc/kcxq/kcxq?id=${id}`;
        break;
      case 'expert':
        url = `/pages/consult/consultDetails/consultDetails?id=${id}`;
        break;
      case 'article':
        url = `/pages/index/article/articleDetail/articleDetail?id=${id}`;
        break;
      case 'test':
        // 需要确认心理测试详情页的路径
        url = `/pages/index/PsychologicalTest/PsychologicalTest?id=${id}`; 
        break;
      default:
        return;
    }

    wx.navigateTo({ url });
  },

  // 点击历史记录
  onHistoryClick(e) {
    const content = e.currentTarget.dataset.content;
    this.setData({ searchValue: content });
    this.performSearch(content);
  },

  // 清空历史记录 (复用您已有的逻辑)
  clearHistory() {
    const userId = app.globalData.userInfo?.id;
    if (!userId) {
      wx.showToast({ title: '用户未登录', icon: 'none' });
      return;
    }

    wx.showModal({
      title: '确认清空？',
      content: '确定要清空所有搜索记录吗？',
      success: (res) => {
        if (res.confirm) {
          wx.request({
            url: this.data.url + 'userSearchRecord/clear?userId=' + encodeURIComponent(userId),
            method: 'DELETE',
            success: (delRes) => {
              if (delRes.statusCode === 200 && delRes.data.code === 200) {
                this.setData({ userSearchRecords: [] });
                wx.showToast({ title: '已清空', icon: 'success' });
              } else {
                wx.showToast({ title: delRes.data?.msg || '删除失败', icon: 'none' });
              }
            },
            fail: (err) => {
              console.error('【删除搜索记录失败】', err);
              wx.showToast({ title: '网络错误', icon: 'none' });
            }
          });
        }
      }
    });
  },

  // 获取历史记录 (复用)
  getUserSearchRecord() {
    const userId = app.globalData.userInfo?.id;
    if (!userId) return;

    wx.request({
      url: this.data.url + 'userSearchRecord/user/' + userId,
      method: 'GET',
      success: (resp) => {
        if (resp.data?.data) {
          this.setData({ userSearchRecords: resp.data.data });
        }
      }
    });
  },

  // 取消按钮
  onCancel() {
    wx.switchTab({ url: '/pages/index/index' });
  },

  // 计算是否所有结果都为空 (用于显示“未找到”)
  allResultsEmpty() {
    return (
      this.data.courseResults.length === 0 &&
      this.data.expertResults.length === 0 &&
      this.data.articleResults.length === 0 &&
      this.data.testResults.length === 0
    );
  }
});